package com.atguigu.gmall.product.service.impl;

import com.alibaba.fastjson.JSONObject;
import com.atguigu.gmall.model.product.*;
import com.atguigu.gmall.product.mapper.*;
import com.atguigu.gmall.product.service.ManageService;
import com.baomidou.mybatisplus.core.conditions.query.QueryWrapper;
import com.baomidou.mybatisplus.core.metadata.IPage;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

/**
 * 后台管理平台中心
 * @author aaronmegs
 * @create 2020-02-18 7:45 下午
 */
@Service
public class ManageServiceImpl implements ManageService {

    @Autowired
    private BaseCategory1Mapper baseCategory1Mapper;

    @Autowired
    private BaseCategory2Mapper baseCategory2Mapper;

    @Autowired
    private BaseCategory3Mapper baseCategory3Mapper;

    @Autowired
    private BaseAttrInfoMapper baseAttrInfoMapper;

    @Autowired
    private BaseAttrValueMapper baseAttrValueMapper;

    @Autowired
    private SpuInfoMapper spuInfoMapper;

    @Autowired
    private BaseSaleAttrMapper baseSaleAttrMapper;

    @Autowired
    private BaseTrademarkMapper baseTrademarkMapper;

    @Autowired
    private SpuImageMapper spuImageMapper;

    @Autowired
    private SpuSaleAttrMapper spuSaleAttrMapper;

    @Autowired
    private SpuSaleAttrValueMapper spuSaleAttrValueMapper;

    @Autowired
    private SkuInfoMapper skuInfoMapper;

    @Autowired
    private SkuImageMapper skuImageMapper;

    @Autowired
    private SkuAttrValueMapper skuAttrValueMapper;

    @Autowired
    private SkuSaleAttrValueMapper skuSaleAttrValueMapper;

    @Autowired
    private BaseCategoryViewMapper baseCategoryViewMapper;

    // 获取一级分类 集合
    @Override
    public List<BaseCategory1> getCategory1() {
        return baseCategory1Mapper.selectList(null);
    }

    // 获取二级分类 集合
    @Override
    public List<BaseCategory2> getCategory2(Long category1Id) {
        QueryWrapper<BaseCategory2> queryWrapper = new QueryWrapper<>();
        queryWrapper.eq("category1_id", category1Id);
        List<BaseCategory2> category2List = baseCategory2Mapper.selectList(queryWrapper);
        return category2List;
    }

    // 获取三级分类 集合
    @Override
    public List<BaseCategory3> getCategory3(Long category2Id) {
        QueryWrapper<BaseCategory3> wrapper = new QueryWrapper<>();
        wrapper.eq("category2_id", category2Id);
        return baseCategory3Mapper.selectList(wrapper);
    }

    // 获取平台属性及属性值集合
    @Override
    public List<BaseAttrInfo> attrInfoList(Long category1Id, Long category2Id, Long category3Id) {
        return baseAttrInfoMapper.attrInfoList(category1Id, category2Id, category3Id);
    }

    // 保存平台属性及属性值
    @Override
    public void saveAttrInfo(BaseAttrInfo baseAttrInfo) {
        // 1.平台属性表 1
        baseAttrInfoMapper.insert(baseAttrInfo);
        // 2.平台属性值表 多
        List<BaseAttrValue> baseAttrValueList = baseAttrInfo.getAttrValueList();
        baseAttrValueList.forEach(v -> {
            // 设置外键
            v.setAttrId(baseAttrInfo.getId());
            baseAttrValueMapper.insert(v);
        });
    }

    // 获取Spu分页列表
    @Override
    public IPage getSpuPage(Integer page, Integer limit, Long category3Id) {
        // page 当前页
        // limit 每页数
        IPage<SpuInfo> ipage = spuInfoMapper.selectPage(new Page<>(page, limit),
                new QueryWrapper<SpuInfo>().eq("category3_id", category3Id));
        return ipage;
    }

    // 查询基本销售属性列表
    @Override
    public List<BaseSaleAttr> baseSaleAttrList() {
        List<BaseSaleAttr> baseSaleAttrList = baseSaleAttrMapper.selectList(null);
        return baseSaleAttrList;
    }

    // 查询品牌列表
    @Override
    public List<BaseTrademark> getTrademarkList() {
        List<BaseTrademark> baseTrademarkList = baseTrademarkMapper.selectList(null);
        return baseTrademarkList;
    }

    @Override
    public void saveSpuInfo(SpuInfo spuInfo) {
        // 1.保存SPU数据 spu_info
        spuInfoMapper.insert(spuInfo);
        Long spuId = spuInfo.getId();

        // 2.保存SPU数据 spu_image
        List<SpuImage> spuImageList = spuInfo.getSpuImageList();
        if (null != spuImageList && spuImageList.size() > 0) {
            spuImageList.forEach(spuImage -> {
                // 外键
                spuImage.setSpuId(spuId);
                spuImageMapper.insert(spuImage);
            });
        }

        // 3.保存SPU数据 spu_sale_attr
        List<SpuSaleAttr> spuSaleAttrList = spuInfo.getSpuSaleAttrList();
        if (null != spuSaleAttrList && spuSaleAttrList.size() > 0) {
            spuSaleAttrList.forEach(ssa -> {
                // 外键
                ssa.setSpuId(spuId);
                // 保存销售属性
                spuSaleAttrMapper.insert(ssa);

                // 4.保存SPU数据 spu_sale_attr_value
                List<SpuSaleAttrValue> spuSaleAttrValueList = ssa.getSpuSaleAttrValueList();
                if (null != spuSaleAttrValueList && spuSaleAttrValueList.size() > 0) {
                    spuSaleAttrValueList.forEach(ssav -> {
                        // 外键
                        ssav.setSpuId(spuId);
                        // 销售属性名称（冗余）
                        ssav.setSaleAttrName(ssa.getSaleAttrName());
                        spuSaleAttrValueMapper.insert(ssav);
                    });
                }
            });
        }
    }

    // 获取品牌分页列表
    @Override
    public IPage getTrademarkPage(Integer page, Integer limit) {
        IPage<BaseTrademark> baseTrademarkIPage = baseTrademarkMapper.selectPage(new Page<BaseTrademark>(page, limit), null);
        return baseTrademarkIPage;
    }

    // 获取SKU分裂列表
    @Override
    public IPage<SkuInfo> list(IPage<SkuInfo> skuInfoIPage) {
        return skuInfoMapper.selectPage(skuInfoIPage, null);
    }

    // 根据spuId获取图片列表
    @Override
    public List<SpuImage> spuImageList(Long spuId) {
        return spuImageMapper.selectList(new QueryWrapper<SpuImage>().eq("spu_id", spuId));
    }

    // 根据spuId获取此商品的销售属性及属性值
    @Override
    public List<SpuSaleAttr> spuSaleAttrList(Long spuId) {
        // 1.SPU销售属性表 SPU销售属性值表
        return spuSaleAttrMapper.spuSaleAttrList(spuId);
    }

    // 保存SKU数据
    @Override
    public void saveSkuInfo(SkuInfo skuInfo) {
        // 1.保存SKU信息 sku_info
        skuInfoMapper.insert(skuInfo);
        Long skuId = skuInfo.getId();
        Long spuId = skuInfo.getSpuId();

        // 2.保存SKU信息 sku_image
        List<SkuImage> skuImageList = skuInfo.getSkuImageList();
        if (null != skuImageList && skuImageList.size() > 0) {
            skuImageList.forEach(skuImage -> {
                // 外键
                skuImage.setSkuId(skuId);
                skuImageMapper.insert(skuImage);
            });
        }

        // 3.保存SKU信息 sku_attr_value 平爱属性及属性值
        List<SkuAttrValue> skuAttrValueList = skuInfo.getSkuAttrValueList();
        if (null != skuAttrValueList && skuAttrValueList.size() > 0) {
            skuAttrValueList.forEach(sav -> {
                sav.setSkuId(skuId);
                skuAttrValueMapper.insert(sav);
            });
        }

        // 4.保存SKU信息 sku_sale_attr_value 销售属性及属性表
        List<SkuSaleAttrValue> skuSaleAttrValueList = skuInfo.getSkuSaleAttrValueList();
        if (null != skuSaleAttrValueList && skuSaleAttrValueList.size() > 0) {
            skuSaleAttrValueList.forEach(ssav -> {
                // 库存表的主键
                ssav.setSkuId(skuId);
                // 商品表的主键
                ssav.setSpuId(spuId);
                skuSaleAttrValueMapper.insert(ssav);
            });
        }
    }

    // 上架
    @Override
    public void onSale(Long skuId) {
        SkuInfo skuInfo = new SkuInfo();
        skuInfo.setId(skuId);
        skuInfo.setIsSale(1);   // 1 表示上架
        skuInfoMapper.updateById(skuInfo);
    }

    // 下架
    @Override
    public void cancelSale(Long skuId) {
        SkuInfo skuInfo = new SkuInfo();
        skuInfo.setId(skuId);
        skuInfo.setIsSale(0);   // 0 表示下架
        skuInfoMapper.updateById(skuInfo);
    }

    // 根据SkuId查询SkuInfo 及图片
    @Override
    public SkuInfo getSkuInfo(Long skuId) {
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        // 查询图片
        List<SkuImage> skuImageList = skuImageMapper.selectList(new QueryWrapper<SkuImage>().eq("sku_id", skuId));
        skuInfo.setSkuImageList(skuImageList);
        return skuInfo;
    }

    // 根据三级分类ID查询分类视图
    @Override
    public BaseCategoryView getCategoryView(Long category3Id) {
        return baseCategoryViewMapper.selectById(category3Id);
    }

    @Override
    public List<SpuSaleAttr> getSpuSaleAttrListCheckBySku(Long skuId, Long spuId) {
        return spuSaleAttrMapper.getSpuSaleAttrListCheckBySku(skuId, spuId);
    }

    //点击其他销售属性值的组合，跳转到另外的sku页面
    //{“1|5|7”:”1”,“1|4|7”:”2”,.....}
    @Override
    public Map getSkuValueIdsMap(Long spuId) {
        List<Map> mapList =skuSaleAttrValueMapper.getSkuValueIdsMap(spuId);
        // Map1 sku_id 1 value_ids 1|5|7
        // Map2 sku_is 2 value_ids 1|4|7
        Map map = new HashMap();
        mapList.forEach(m -> {
            map.put(m.get("value_ids"), m.get("sku_id"));
        });
        return map;
    }

    // 单独获取库存的价格
    @Override
    public BigDecimal getSkuPrice(Long skuId) {
        SkuInfo skuInfo = skuInfoMapper.selectById(skuId);
        if (null != skuInfo) {
            return skuInfo.getPrice();
        } else {
            return null;
        }
    }

    // 为了首页加载一二三级商品分类
    @Override
    public List<JSONObject> getBaseCategoryList() {
        // 最总返回结果
        List<JSONObject> result = new ArrayList<>();
        // 1.一二三级分类的视图 所有结果
        List<BaseCategoryView> baseCategoryViewList = baseCategoryViewMapper.selectList(null);
        // 对上面的集合按照一级分类ID进行分组 之后返回集合
        // 返回值Map K:一级分类的ID     V:集合
        // Map1  K : 1      V 图片、印象、对应的集合 60长度
        // Map2  K : 2      V:手机对应的集合  24长度
        // Map3  K : 3      V: 家用电器 对应的集合 24长度
        Map<Long, List<BaseCategoryView>> category1IdList = baseCategoryViewList.stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory1Id));
        // 2.一级分类组长数据机构
        // 1） 角标 从1开始
        int index = 1;
        for (Map.Entry<Long, List<BaseCategoryView>> category1IdEntry : category1IdList.entrySet()) {
            JSONObject category1IdJsonObject = new JSONObject();
            category1IdJsonObject.put("index", index++);
            // 2) 一级分类ID
            category1IdJsonObject.put("categoryId", category1IdEntry.getKey());
            // 3)一级分类的名称
            category1IdJsonObject.put("categoryName", category1IdEntry.getValue().get(0).getCategory1Name());

            // 准备二级分类的集合
            // Map1  K : 二级分类的ID 13     V：集合 2长度
            // Map2  K : 二级分类的ID 14     V：集合 4长度
            Map<Long, List<BaseCategoryView>> category2IdList = category1IdEntry.getValue().stream().collect(Collectors.groupingBy(BaseCategoryView::getCategory2Id));
            // 二级分类集合
            List<JSONObject> category2IdJSONObject = new ArrayList<>();
            for (Map.Entry<Long, List<BaseCategoryView>> category2IdEntry : category2IdList.entrySet()) {
                JSONObject category2IdJsonObject = new JSONObject();
                // 1)二级分类的ID
                category2IdJsonObject.put("categoryId", category2IdEntry.getKey());
                // 2）二级分类的名称
                category2IdJsonObject.put("categoryName", category2IdEntry.getValue().get(0).getCategory2Name());

                // 准备三级分类的集合
                List<JSONObject> category3List = category2IdEntry.getValue().stream().map(category3 -> {
                    JSONObject category3IdJsonObject = new JSONObject();
                    // 1）三级分类的ID
                    category3IdJsonObject.put("categoryId", category3.getCategory3Id());
                    // 2) 三级分类的名称
                    category3IdJsonObject.put("categoryName", category3.getCategory3Name());
                    return category3IdJsonObject;
                }).collect(Collectors.toList());
                // 3)二级分类的孩子
                category2IdJsonObject.put("categoryChild", category3List);
                // 追加每一个二级分类对象
                category2IdJSONObject.add(category2IdJsonObject);
            }

            // 4)一级分类的所有孩子 （二级分类的集合） categoryChild
            category1IdJsonObject.put("categoryChild", category2IdJSONObject);
            // 追加一个一级分类对象
            result.add(category1IdJsonObject);
        }

        return result;
    }
}
